<template>
  <!-- 进度管理 -->
  <bounced :show="scheduleShow" title="进度管理" @onClone="scheduleFun">
    <div class="scheduleDialog barchart">
      <div class="inputBox">
        <el-date-picker
          v-if="scheduleIndex == 3"
          @change="weekChange"
          v-model="week"
          :value="week"
          type="week"
          format="yyyy-MM-dd 第WW周"
          placeholder="选择周"
        >
        </el-date-picker>
        <el-date-picker
          v-if="scheduleIndex == 2"
          @change="monthChange"
          v-model="month"
          type="month"
          format="yyyy-MM"
          placeholder="选择月"
        >
        </el-date-picker>
      </div>
      <el-table
        :data="tableData"
        height="520"
        style="border: 1px solid #495a79"
        :header-cell-style="{
          background: '#104584',
          color: '#fff',
          borderColor: '#495A79',
        }"
        :cell-style="{
          background: '#0C2451',
          color: '#fff',
          borderColor: '#495A79',
        }"
        @header-click="headerClick"
        @cell-click="cellClick"
      >
        <el-table-column
          fixed
          align="center"
          prop="majorName"
          label="专业"
          width="100"
          key="-1"
        >
        </el-table-column>
        <el-table-column
          fixed
          align="center"
          prop="nodeName"
          label="一级节点进度"
          width="100"
          key="-2"
        >
        </el-table-column>
        <el-table-column
          fixed
          align="center"
          prop="parentName"
          label="二级节点进度"
          width="100"
          key="-3"
        >
        </el-table-column>
        <el-table-column
          fixed
          align="center"
          prop="days"
          label="工期(天)"
          width="100"
          key="-7"
        >
        </el-table-column>
        <el-table-column
          fixed
          align="center"
          prop="startTime"
          label="开始时间"
          width="100"
          key="-5"
        >
          <template slot-scope="scope">
            <span>{{ scope.row.startTime }}</span>
          </template>
        </el-table-column>
        <el-table-column
          fixed
          align="center"
          prop="endTime"
          label="结束时间"
          width="100"
          key="-6"
        >
          <template slot-scope="scope">
            <span>{{ scope.row.endTime }}</span>
          </template>
        </el-table-column>

        <!-- 渲染时间(年|月) -->
        <template v-if="IsShowyear">
          <el-table-column
            v-for="(item, index) in showMonths"
            :label="item.year"
            prop="showMonths"
            align="center"
            :key="index"
          >
            <el-table-column
              v-for="(it, index1) in item.months"
              :label="it.str"
              :index="index1"
              :data-year="item.year"
              prop="str"
              min-width="30"
              style="padding: 0; margin: 0"
              align="center"
              :key="index1"
            >
              <template slot-scope="scope" class="progressCon">
                <div v-if="getCellDateWidth > 0">
                  <div
                    class="progressUpon"
                    :style="{
                      width: optimizeCalcWidth(scope.row),
                      left: optimizeCalcLeft(scope.row),
                    }"
                  ></div>
                </div>
                <div v-else>
                  <div
                    :class="
                      scope.row.beginTimeStamp <= it.endTimeStamp &&
                      scope.row.endTimeStamp >= it.beginTimeStamp
                        ? 'progressUpon'
                        : ''
                    "
                    :style="{
                      width:
                        scope.row.beginTimeStamp <= it.endTimeStamp &&
                        scope.row.endTimeStamp >= it.beginTimeStamp
                          ? calcwidth(scope.row, it)
                          : '0px',
                      left:
                        scope.row.beginTimeStamp <= it.endTimeStamp &&
                        scope.row.endTimeStamp >= it.beginTimeStamp
                          ? calcLeft(scope.row, it)
                          : '0px',
                    }"
                  ></div>
                </div>
              </template>
            </el-table-column>
          </el-table-column>
        </template>
        <!-- 渲染时间(月|日) -->
        <template v-if="!IsShowyear">
          <el-table-column
            v-for="(item, index) in showMonths"
            :label="item.year"
            prop="year"
            align="center"
            :key="index"
          >
            <el-table-column
              v-for="(it, index1) in item.months"
              :label="it.str + ''"
              prop="str"
              style="padding: 0; margin: 0"
              align="center"
              :key="index1"
              @click="monthsClick(item.year, it.str)"
            >
              <el-table-column
                v-for="(itm, index2) in item.days[index1].daysArr"
                :label="itm.day + ''"
                prop="day"
                min-width="40"
                style="padding: 0; margin: 0"
                align="center"
                :key="index2"
                @click="dayClick(item.year, it.str, itm.day)"
              >
                <template slot-scope="scope" class="progressCon">
                  <div v-if="getCellDateWidth > 0">
                    <div
                      v-if="index === 0 && index1 === 0"
                      class="progressUpon"
                      :style="{
                        width: optimizeCalcWidth(scope.row),
                        left: optimizeCalcLeft(scope.row),
                      }"
                    ></div>
                  </div>
                  <div v-else>
                    <div
                      :class="
                        scope.row.beginTimeStamp <= itm.timestamp &&
                        scope.row.endTimeStamp >= itm.timestamp &&
                        itm.timestamp > 0
                          ? 'progressUpon'
                          : ''
                      "
                      style="width: calc(100% + 4px); min-width: 1px"
                    ></div>
                  </div>
                </template>
              </el-table-column>
            </el-table-column>
          </el-table-column>
        </template>
      </el-table>
    </div>
  </bounced>
</template>

<script>
import bounced from "../../bounced.vue";
import api from "@/util/api";
import * as dayjs from "dayjs";
export default {
  components: {
    bounced,
  },
  name: "projectDialog",
  data() {
    return {
      projectDialog: `<div>1111111111</div>`,
      showMonths: [],
      minDay: "", // 最小日期
      maxDay: "", // 最大日期
      IsShowyear: false, // 显示年|月 、 月|日,
      week: "",
      month: new Date(),
    };
  },
  mounted() {
    // this.$set(this, 'month', dayjs())
  },
  computed: {
    scheduleShow: function () {
      return this.$store.state.scheduleShow;
    },
    tableData: function () {
      return this.$store.state.tableData;
    },
    scheduleIndex: function () {
      return this.$store.state.scheduleIndex;
    },
    // 获取最小日期-月开始时间戳
    minDayTimeStamp() {
      if (this.IsShowyear) {
        return this.showMonths[0].months[0].beginTimeStamp;
      } else {
        return this.showMonths[0].days[0].daysArr[0].timestamp;
      }
    },
    // 获取最大日期时间戳
    maxDayTimeStamp() {
      let Length = this.showMonths.length; // 年有多少个
      // 如果显示年|月 与 月|日 是不同的
      if (this.IsShowyear) {
        let monthsLength = this.showMonths[Length - 1].months.length; //月有多少个
        return this.showMonths[Length - 1].months[monthsLength - 1]
          .endTimeStamp;
      } else {
        let daysLength = this.showMonths[Length - 1].days.length;
        let daysarrLength =
          this.showMonths[Length - 1].days[daysLength - 1].daysArr.length; //天有多少个
        return (
          this.showMonths[Length - 1].days[daysLength - 1].daysArr[
            daysarrLength - 1
          ].timestamp + 86400000
        ); //+86400000 是因为时间戳都是0点这样+1天的时间戳，就表示最晚一天的最后的时间
      }
    },
    // 最大日期与最小日期的时间戳差
    maxAndminDayTimeStamp() {
      return this.maxDayTimeStamp - this.minDayTimeStamp;
    },
    // 获取日期单元格宽度 => 如果返回0则只用之前第一版的计算方法
    getCellDateWidth() {
      let num = 0; // 获取日期单元格数量
      if (this.IsShowyear) {
        // 月数量
        for (let i = 0; i < this.showMonths.length; i++) {
          num += this.showMonths[i].months.length;
        }
      } else {
        // 天数量
        for (let i = 0; i < this.showMonths.length; i++) {
          for (let j = 0; j < this.showMonths[i].days.length; j++) {
            num += this.showMonths[i].days[j].daysArr.length;
          }
        }
      }

      // 每个单元格最小30宽度
      let MaxWidth = window.screen.width;
      let CellNum = MaxWidth / 30 > 0 ? MaxWidth / 30 : 0;
      if (num >= CellNum) {
        // 页面宽 / 单元格最小宽度 = 最多放下的值
        return num * 30;
      } else {
        // 单元格的值，就不能是最小值30了
        // 需要获取dom的宽度，在进行计算，但是dom还未渲染完成，因此这里就不考虑了，直接只用第一版的方法动态计算
        // TODO
        return 0;
      }
    },
  },
  watch: {
    tableData() {
      console.log("watchtableData", this.tableData);
      this.setrowspans(); // 设置合并
      this.getChartTitle(); // 渲染的信息
    },
    scheduleShow() {
      this.week = "";
      this.month = "";
    },
  },
  created() {
    // 这里可以发送请求
    // this.tableData = [{
    //         "id": 32,
    //         "nodeName": "RTO氧化装置负挖及基础换填",
    //         "parentNode": 1,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2021-07-25",
    //         "endTime": "2021-08-13",
    //         "majorName": "土建工程",
    //         "parentName": "RTO氧化装置"
    //     },
    //     {
    //         "id": 33,
    //         "nodeName": "RTO氧化装置基础施工",
    //         "parentNode": 1,
    //         "nodeType": 2,
    //         "duration": 35,
    //         "startTime": "2021-08-14",
    //         "endTime": "2021-09-17",
    //         "majorName": "土建工程",
    //         "parentName": "RTO氧化装置"
    //     },
    //     {
    //         "id": 34,
    //         "nodeName": "RTO氧化装置辅助设备基础施工",
    //         "parentNode": 1,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2021-09-18",
    //         "endTime": "2021-10-07",
    //         "majorName": "土建工程",
    //         "parentName": "RTO氧化装置"
    //     },
    //     {
    //         "id": 35,
    //         "nodeName": "RTO氧化装置电子间结构施工",
    //         "parentNode": 1,
    //         "nodeType": 2,
    //         "duration": 25,
    //         "startTime": "2021-10-08",
    //         "endTime": "2021-11-01",
    //         "majorName": "土建工程",
    //         "parentName": "RTO氧化装置"
    //     },
    //     {
    //         "id": 36,
    //         "nodeName": "RTO氧化装置电子间建筑施工",
    //         "parentNode": 1,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2021-11-02",
    //         "endTime": "2021-11-21",
    //         "majorName": "土建工程",
    //         "parentName": "RTO氧化装置"
    //     },
    //     {
    //         "id": 37,
    //         "nodeName": "基础负挖及基础换填",
    //         "parentNode": 2,
    //         "nodeType": 2,
    //         "duration": 19,
    //         "startTime": "2021-07-25",
    //         "endTime": "2021-08-12",
    //         "majorName": "土建工程",
    //         "parentName": "锅炉及主厂房结构"
    //     },
    //     {
    //         "id": 38,
    //         "nodeName": "锅炉基础施工",
    //         "parentNode": 2,
    //         "nodeType": 2,
    //         "duration": 15,
    //         "startTime": "2021-08-13",
    //         "endTime": "2021-08-27",
    //         "majorName": "土建工程",
    //         "parentName": "锅炉及主厂房结构"
    //     },
    //     {
    //         "id": 39,
    //         "nodeName": "基础养护及回填（锅炉",
    //         "parentNode": 2,
    //         "nodeType": 2,
    //         "duration": 28,
    //         "startTime": "2021-08-28",
    //         "endTime": "2021-09-24",
    //         "majorName": "土建工程",
    //         "parentName": "锅炉及主厂房结构"
    //     },
    //     {
    //         "id": 40,
    //         "nodeName": "主厂房A、B、C排一层结构施工",
    //         "parentNode": 2,
    //         "nodeType": 2,
    //         "duration": 25,
    //         "startTime": "2021-09-10",
    //         "endTime": "2021-10-04",
    //         "majorName": "土建工程",
    //         "parentName": "锅炉及主厂房结构"
    //     },
    //     {
    //         "id": 41,
    //         "nodeName": "主厂房A、B、C排二层结构施工",
    //         "parentNode": 2,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2021-10-04",
    //         "endTime": "2021-10-23",
    //         "majorName": "土建工程",
    //         "parentName": "锅炉及主厂房结构"
    //     },
    //     {
    //         "id": 42,
    //         "nodeName": "主厂房A、B、C排其余上部结构",
    //         "parentNode": 2,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2021-10-24",
    //         "endTime": "2021-11-12",
    //         "majorName": "土建工程",
    //         "parentName": "锅炉及主厂房结构"
    //     },
    //     {
    //         "id": 43,
    //         "nodeName": "主厂房钢屋架安装",
    //         "parentNode": 2,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2021-11-19",
    //         "endTime": "2021-12-08",
    //         "majorName": "土建工程",
    //         "parentName": "锅炉及主厂房结构"
    //     },
    //     {
    //         "id": 44,
    //         "nodeName": "汽轮发电机基础筏板检测",
    //         "parentNode": 3,
    //         "nodeType": 2,
    //         "duration": 3,
    //         "startTime": "2021-08-10",
    //         "endTime": "2021-08-12",
    //         "majorName": "土建工程",
    //         "parentName": "汽轮发电机基础"
    //     },
    //     {
    //         "id": 45,
    //         "nodeName": "汽轮发电机基础上部结构施工",
    //         "parentNode": 3,
    //         "nodeType": 2,
    //         "duration": 25,
    //         "startTime": "2021-09-20",
    //         "endTime": "2021-10-14",
    //         "majorName": "土建工程",
    //         "parentName": "汽轮发电机基础"
    //     },
    //     {
    //         "id": 46,
    //         "nodeName": "汽轮机润滑油基础施工",
    //         "parentNode": 3,
    //         "nodeType": 2,
    //         "duration": 10,
    //         "startTime": "2021-11-10",
    //         "endTime": "2021-11-19",
    //         "majorName": "土建工程",
    //         "parentName": "汽轮发电机基础"
    //     },
    //     {
    //         "id": 47,
    //         "nodeName": "发电机出线小室施工",
    //         "parentNode": 3,
    //         "nodeType": 2,
    //         "duration": 10,
    //         "startTime": "2021-11-30",
    //         "endTime": "2021-12-09",
    //         "majorName": "土建工程",
    //         "parentName": "汽轮发电机基础"
    //     },
    //     {
    //         "id": 48,
    //         "nodeName": "空冷岛基础及结构施工",
    //         "parentNode": 4,
    //         "nodeType": 2,
    //         "duration": 36,
    //         "startTime": "2021-10-20",
    //         "endTime": "2021-11-24",
    //         "majorName": "土建工程",
    //         "parentName": "辅助系统构筑物\r"
    //     },
    //     {
    //         "id": 49,
    //         "nodeName": "主变基础施工",
    //         "parentNode": 4,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2021-10-30",
    //         "endTime": "2021-11-18",
    //         "majorName": "土建工程",
    //         "parentName": "辅助系统构筑物\r"
    //     },
    //     {
    //         "id": 50,
    //         "nodeName": "引风机基础施工",
    //         "parentNode": 4,
    //         "nodeType": 2,
    //         "duration": 15,
    //         "startTime": "2021-08-18",
    //         "endTime": "2021-09-06",
    //         "majorName": "土建工程",
    //         "parentName": "辅助系统构筑物\r"
    //     },
    //     {
    //         "id": 51,
    //         "nodeName": "汽机房零米设备基础施工",
    //         "parentNode": 4,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2021-11-20",
    //         "endTime": "2021-12-09",
    //         "majorName": "土建工程",
    //         "parentName": "辅助系统构筑物\r"
    //     },
    //     {
    //         "id": 52,
    //         "nodeName": "GIS基础施工",
    //         "parentNode": 4,
    //         "nodeType": 2,
    //         "duration": 16,
    //         "startTime": "2021-10-20",
    //         "endTime": "2021-11-04",
    //         "majorName": "土建工程",
    //         "parentName": "辅助系统构筑物\r"
    //     },
    //     {
    //         "id": 53,
    //         "nodeName": "小锅炉基础施工",
    //         "parentNode": 4,
    //         "nodeType": 2,
    //         "duration": 10,
    //         "startTime": "2021-08-30",
    //         "endTime": "2021-09-08",
    //         "majorName": "土建工程",
    //         "parentName": "辅助系统构筑物\r"
    //     },
    //     {
    //         "id": 54,
    //         "nodeName": "烟囱基础 ",
    //         "parentNode": 4,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2021-08-30",
    //         "endTime": "2021-09-18",
    //         "majorName": "土建工程",
    //         "parentName": "辅助系统构筑物\r"
    //     },
    //     {
    //         "id": 55,
    //         "nodeName": "化学制水间设备基础施工",
    //         "parentNode": 5,
    //         "nodeType": 2,
    //         "duration": 16,
    //         "startTime": "2021-09-10",
    //         "endTime": "2021-09-25",
    //         "majorName": "土建工程",
    //         "parentName": "化水制水及加药系统施工"
    //     },
    //     {
    //         "id": 56,
    //         "nodeName": "化学制水间结构施工",
    //         "parentNode": 5,
    //         "nodeType": 2,
    //         "duration": 28,
    //         "startTime": "2021-09-24",
    //         "endTime": "2021-10-21",
    //         "majorName": "土建工程",
    //         "parentName": "化水制水及加药系统施工"
    //     },
    //     {
    //         "id": 57,
    //         "nodeName": "化学制水间建筑施工",
    //         "parentNode": 5,
    //         "nodeType": 2,
    //         "duration": 10,
    //         "startTime": "2021-11-14",
    //         "endTime": "2021-12-03",
    //         "majorName": "土建工程",
    //         "parentName": "化水制水及加药系统施工"
    //     },
    //     {
    //         "id": 58,
    //         "nodeName": "化学加药装置基础施工",
    //         "parentNode": 5,
    //         "nodeType": 2,
    //         "duration": 10,
    //         "startTime": "2021-12-14",
    //         "endTime": "2021-12-23",
    //         "majorName": "土建工程",
    //         "parentName": "化水制水及加药系统施工"
    //     },
    //     {
    //         "id": 59,
    //         "nodeName": "空压机房基础施工",
    //         "parentNode": 6,
    //         "nodeType": 2,
    //         "duration": 16,
    //         "startTime": "2021-08-24",
    //         "endTime": "2021-09-08",
    //         "majorName": "土建工程",
    //         "parentName": "压缩空气系统施工"
    //     },
    //     {
    //         "id": 60,
    //         "nodeName": "空压机房结构施工",
    //         "parentNode": 6,
    //         "nodeType": 2,
    //         "duration": 21,
    //         "startTime": "2021-10-29",
    //         "endTime": "2021-11-18",
    //         "majorName": "土建工程",
    //         "parentName": "压缩空气系统施工"
    //     },
    //     {
    //         "id": 61,
    //         "nodeName": "空压机房建筑施工 ",
    //         "parentNode": 6,
    //         "nodeType": 2,
    //         "duration": 26,
    //         "startTime": "2021-11-19",
    //         "endTime": "2021-12-14",
    //         "majorName": "土建工程",
    //         "parentName": "压缩空气系统施工"
    //     },
    //     {
    //         "id": 62,
    //         "nodeName": "空压机基础施工",
    //         "parentNode": 6,
    //         "nodeType": 2,
    //         "duration": 7,
    //         "startTime": "2021-10-22",
    //         "endTime": "2021-10-28",
    //         "majorName": "土建工程",
    //         "parentName": "压缩空气系统施工"
    //     },
    //     {
    //         "id": 63,
    //         "nodeName": "乏风管廊基础施工",
    //         "parentNode": 7,
    //         "nodeType": 2,
    //         "duration": 40,
    //         "startTime": "2021-08-20",
    //         "endTime": "2021-09-28",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "乏风管廊施工"
    //     },
    //     {
    //         "id": 64,
    //         "nodeName": "乏风管廊结构施工",
    //         "parentNode": 7,
    //         "nodeType": 2,
    //         "duration": 70,
    //         "startTime": "2021-08-15",
    //         "endTime": "2021-10-23",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "乏风管廊施工"
    //     },
    //     {
    //         "id": 65,
    //         "nodeName": "烟风管廊基础施工 ",
    //         "parentNode": 8,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2021-08-30",
    //         "endTime": "2021-09-18",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "烟风管廊施工"
    //     },
    //     {
    //         "id": 66,
    //         "nodeName": "烟风管廊结构施工 ",
    //         "parentNode": 8,
    //         "nodeType": 2,
    //         "duration": 30,
    //         "startTime": "2021-10-19",
    //         "endTime": "2021-11-17",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "烟风管廊施工"
    //     },
    //     {
    //         "id": 67,
    //         "nodeName": "厂区道路路基施工",
    //         "parentNode": 9,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2022-05-10",
    //         "endTime": "2022-05-29",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "厂区道路、围墙、门卫"
    //     },
    //     {
    //         "id": 68,
    //         "nodeName": "厂区道路路面施工 ",
    //         "parentNode": 9,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2022-06-01",
    //         "endTime": "2022-06-20",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "厂区道路、围墙、门卫"
    //     },
    //     {
    //         "id": 69,
    //         "nodeName": "厂区道路围墙施工",
    //         "parentNode": 9,
    //         "nodeType": 2,
    //         "duration": 10,
    //         "startTime": "2022-06-20",
    //         "endTime": "2022-06-29",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "厂区道路、围墙、门卫"
    //     },
    //     {
    //         "id": 70,
    //         "nodeName": "厂区门卫室施工 ",
    //         "parentNode": 9,
    //         "nodeType": 2,
    //         "duration": 10,
    //         "startTime": "2022-05-10",
    //         "endTime": "2022-05-19",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "厂区道路、围墙、门卫"
    //     },
    //     {
    //         "id": 71,
    //         "nodeName": "消防管道、消防箱安装",
    //         "parentNode": 10,
    //         "nodeType": 2,
    //         "duration": 25,
    //         "startTime": "2022-03-30",
    //         "endTime": "2022-04-23",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "消防系统安装\r"
    //     },
    //     {
    //         "id": 72,
    //         "nodeName": "厂区雨水管安装",
    //         "parentNode": 11,
    //         "nodeType": 2,
    //         "duration": 30,
    //         "startTime": "2022-05-15",
    //         "endTime": "2022-06-13",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "雨水、排水系统安装"
    //     },
    //     {
    //         "id": 73,
    //         "nodeName": "轴流风机安装，空调系统安装",
    //         "parentNode": 12,
    //         "nodeType": 2,
    //         "duration": 60,
    //         "startTime": "2021-11-20",
    //         "endTime": "2022-01-18",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "通风空调系统安装"
    //     },
    //     {
    //         "id": 74,
    //         "nodeName": "110kV外线",
    //         "parentNode": 13,
    //         "nodeType": 2,
    //         "duration": 192,
    //         "startTime": "2021-08-20",
    //         "endTime": "2022-02-27",
    //         "majorName": "门卫、厂区道路、管廊、地坪及围墙施工",
    //         "parentName": "110kV外线施工"
    //     },
    //     {
    //         "id": 75,
    //         "nodeName": "RTO氧化装置钢架",
    //         "parentNode": 14,
    //         "nodeType": 2,
    //         "duration": 30,
    //         "startTime": "2021-11-20",
    //         "endTime": "2021-12-19",
    //         "majorName": "安装工程",
    //         "parentName": "RTO氧化装置安装\r"
    //     },
    //     {
    //         "id": 76,
    //         "nodeName": "RTO氧化装置本体",
    //         "parentNode": 14,
    //         "nodeType": 2,
    //         "duration": 64,
    //         "startTime": "2022-02-20",
    //         "endTime": "2022-04-24",
    //         "majorName": "安装工程",
    //         "parentName": "RTO氧化装置安装\r"
    //     },
    //     {
    //         "id": 77,
    //         "nodeName": "RTO氧化装置辅助设备 ",
    //         "parentNode": 14,
    //         "nodeType": 2,
    //         "duration": 20,
    //         "startTime": "2022-03-30",
    //         "endTime": "2022-04-18",
    //         "majorName": "安装工程",
    //         "parentName": "RTO氧化装置安装\r"
    //     },
    //     {
    //         "id": 78,
    //         "nodeName": "RTO氧化装置保温",
    //         "parentNode": 14,
    //         "nodeType": 2,
    //         "duration": 30,
    //         "startTime": "2022-04-01",
    //         "endTime": "2022-04-30",
    //         "majorName": "安装工程",
    //         "parentName": "RTO氧化装置安装\r"
    //     },
    //     {
    //         "id": 79,
    //         "nodeName": "点火系统安装",
    //         "parentNode": 14,
    //         "nodeType": 2,
    //         "duration": 10,
    //         "startTime": "2022-04-20",
    //         "endTime": "2022-04-29",
    //         "majorName": "安装工程",
    //         "parentName": "RTO氧化装置安装\r"
    //     },
    //     {
    //         "id": 80,
    //         "nodeName": "锅炉钢架吊装 ",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 13,
    //         "startTime": null,
    //         "endTime": null,
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     },
    //     {
    //         "id": 81,
    //         "nodeName": "横梁、顶板梁安装，钢架整体找正",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 15,
    //         "startTime": null,
    //         "endTime": null,
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     },
    //     {
    //         "id": 82,
    //         "nodeName": "平台扶梯预制及安装",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 11,
    //         "startTime": null,
    //         "endTime": null,
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     },
    //     {
    //         "id": 83,
    //         "nodeName": "右水冷壁模块吊装 ",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 11,
    //         "startTime": null,
    //         "endTime": null,
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     },
    //     {
    //         "id": 84,
    //         "nodeName": "后水冷壁模块吊装 ",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 11,
    //         "startTime": null,
    //         "endTime": null,
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     },
    //     {
    //         "id": 85,
    //         "nodeName": "前水冷壁模块吊装",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 11,
    //         "startTime": null,
    //         "endTime": null,
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     },
    //     {
    //         "id": 86,
    //         "nodeName": "左水冷壁模块吊装",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 10,
    //         "startTime": null,
    //         "endTime": null,
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     },
    //     {
    //         "id": 87,
    //         "nodeName": "锅筒吊装找正",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 3,
    //         "startTime": null,
    //         "endTime": null,
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     },
    //     {
    //         "id": 88,
    //         "nodeName": "本体管路安装 ",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 19,
    //         "startTime": null,
    //         "endTime": null,
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     },
    //     {
    //         "id": 89,
    //         "nodeName": "水压试验",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 2,
    //         "startTime": "2022-03-24",
    //         "endTime": "2022-03-25",
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     },
    //     {
    //         "id": 90,
    //         "nodeName": "烟风道预制及安装",
    //         "parentNode": 15,
    //         "nodeType": 2,
    //         "duration": 40,
    //         "startTime": "2022-02-01",
    //         "endTime": "2022-03-12",
    //         "majorName": "安装工程",
    //         "parentName": "锅炉安装\r"
    //     }];
    // this.setrowspans(); // 设置合并
    // this.getChartTitle(); // 渲染的信息
  },
  methods: {
    secondShow({ month, week }) {
      api.secondShow(
        {
          month: month,
          nodeType: 2,
          planLeave: this.scheduleIndex > 1 ? this.scheduleIndex-1 : null,
          planType: this.scheduleIndex - 1,
          startDate: week,
        },
        (res) => {
          res.data.data.plans.map((item) => {
            item.estimateStartTime = dayjs(item.estimateStartTime).format(
              "YYYY-MM-DD"
            );
            item.estimateEndTime = item.estimateEndTime
              ? dayjs(item.estimateEndTime).format("YYYY-MM-DD")
              : "";
          });
          this.$store.dispatch("changeFun", {
            str: "scheduleList",
            cont: res.data.data.plans,
          });
          res.data.data.progresses.map((item) => {
            item.startTime = item.startTime
              ? dayjs(item.startTime).format("YYYY-MM-DD")
              : "";
            item.endTime = item.endTime
              ? dayjs(item.endTime).format("YYYY-MM-DD")
              : "";
          });
          this.$store.dispatch("changeFun", {
            str: "tableData",
            cont: res.data.data.progresses,
          });
          // this.tableData = res.data.data.progresses;
        }
      );
    },

    scheduleFun(data) {
      let that = this;
      that.$store.dispatch("changeFun", {
        str: "scheduleShow",
        cont: data,
      });
    },
    // 选择月
    monthChange(e) {
      console.log("this.month", this.month);
      let month = dayjs(this.month).format("YYYY-MM"),
        week = null;
      this.secondShow({ month, week });
    },
    // 选择周
    weekChange(e) {
      console.log("this.week", this.week);
      let week = dayjs(this.week).format("YYYY-MM-DD"),
        month = null;
      this.secondShow({ month, week });
    },

    //计算时间差
    datedifference(date1, date2) {
      //sDate1和sDate2是2006-12-18格式
      var dateSpan, tempDate, iDays;
      var sDate1 = this.getTody(date1);
      sDate1 = Date.parse(sDate1);
      var sDate2 = this.getTody(date2);
      sDate2 = Date.parse(sDate2);
      dateSpan = sDate2 - sDate1;
      dateSpan = Math.abs(dateSpan);
      iDays = Math.floor(dateSpan / (24 * 3600 * 1000));
      return iDays;
    },
    optimizeCalcWidth(val) {
      let SumNum = this.maxAndminDayTimeStamp;
      let diffNum = this.IsShowyear
        ? val.endTimeStamp - val.beginTimeStamp
        : val.endTimeStamp + 84600000 - val.beginTimeStamp; // 结束日期 - 开始日期
      let rate = Math.round((diffNum / SumNum) * 10000) / 100.0; //得到百分比
      let widthPx = (this.getCellDateWidth * rate) / 100.0;
      return widthPx + "px";
    },
    optimizeCalcLeft(val) {
      let SumNum = this.maxAndminDayTimeStamp;
      let diffNum = val.beginTimeStamp - this.minDayTimeStamp; // 开始日期 - 整个月开始日期
      let rate = Math.round((diffNum / SumNum) * 10000) / 100.0; //得到百分比
      let leftPx = (this.getCellDateWidth * rate) / 100.0;
      return leftPx + "px";
    },
    // 计算图表的Left
    calcLeft(val, date) {
      // 如果本月的最大时间戳都没有结束时间长，那么就可判断
      if (val.endTimeStamp > date.endTimeStamp) {
        // 如果本月开始日期小于开始日期
        if (val.beginTimeStamp > date.beginTimeStamp) {
          // 进行判断
          let diffNum = val.beginTimeStamp - date.beginTimeStamp;
          let SumNum = date.endTimeStamp - date.beginTimeStamp;
          let rate = 100 - Math.round((diffNum / SumNum) * 10000) / 100.0;
          // 位置判断
          return rate + "%";
        }
      } else if (
        val.endTimeStamp > date.beginTimeStamp &&
        val.endTimeStamp < date.endTimeStamp
      ) {
        // 进行判断
        if (val.beginTimeStamp > date.beginTimeStamp) {
          // 都在一个单元格中
          let diffNum = val.beginTimeStamp - date.beginTimeStamp;
          let SumNum = date.endTimeStamp - date.beginTimeStamp;
          let rate = Math.round((diffNum / SumNum) * 10000) / 100.0;
          // 位置判断
          return rate + "%";
        }
      }
      return "0px";
    },
    // 计算图表的Width
    calcwidth(val, date) {
      console.log("val", val);
      console.log("data", data);
      console.log("IsShowyear", this.IsShowyear);
      if (this.IsShowyear) {
        // 如果是 年|月
        // 1. 如果本月的最大时间戳都没有结束时间长，那么就可设置100%
        // 2. 如果本月的最小时间戳比结束时间长，那么设置0
        // 3. 如果本月的最小时间戳没有结束时间长，那么进行判断
        if (val.endTimeStamp > date.endTimeStamp) {
          // 如果本月开始日期小于开始日期
          if (val.beginTimeStamp > date.beginTimeStamp) {
            // 进行判断
            let diffNum = val.beginTimeStamp - date.beginTimeStamp;
            let SumNum = date.endTimeStamp - date.beginTimeStamp;
            let rate = Math.round((diffNum / SumNum) * 10000) / 100.0;
            return "calc(" + rate + "% + 2px)"; // 结束时间超过本月最大时间戳直接+2px
          }
          return "calc(100% + 2px)";
        } else if (val.endTimeStamp < date.beginTimeStamp) {
          return "0px";
        } else if (
          val.endTimeStamp > date.beginTimeStamp &&
          val.endTimeStamp < date.endTimeStamp
        ) {
          // 进行判断
          if (val.beginTimeStamp > date.beginTimeStamp) {
            // 都在一个单元格中
            let SumNum = date.endTimeStamp - date.beginTimeStamp; // 全月多少数
            let diffNum = val.endTimeStamp - val.beginTimeStamp; // 过程多少数
            diffNum = diffNum === 0 ? 86400000 : diffNum;
            let rate = Math.round((diffNum / SumNum) * 10000) / 100.0;
            return "calc(" + rate + "%)";
          } else {
            // 不在一个单元格中，则不需要判断任何信息
            let diffNum = val.endTimeStamp - date.beginTimeStamp;
            let SumNum = date.endTimeStamp - date.beginTimeStamp;
            let rate = Math.round((diffNum / SumNum) * 10000) / 100.0;
            return "calc(" + rate + "%)";
          }
        }
      } else {
        // 如果是 月|日
        // 1.如果开始时间大于 天的时间戳，则为0
        // 2.如果结束时间小于 天的时间戳，则为100%
        if (val.beginTimeStamp > date.timestamp) {
          return "0px";
        } else if (
          val.beginTimeStamp < date.timestamp &&
          val.endTimeStamp > date.timestamp
        ) {
          return "calc(100% + 2px)";
        }
      }
      return "0px";
    },
    //获得数据相同的行数(网络复制)
    objectSpanMethod({ row, column, rowIndex, columnIndex }) {
      if (columnIndex === 0) {
        return {
          rowspan: row.rowspan,
          colspan: 1,
        };
      }
    },
    // 根据id去分组(网络复制)
    setrowspans() {
      // 先给所有的数据都加一个v.rowspan = 1
      this.tableData.forEach((v) => {
        v.rowspan = 1;
      });
      // 双层循环
      for (let i = 0; i < this.tableData.length; i++) {
        // 内层循环，上面已经给所有的行都加了v.rowspan = 1
        // 这里进行判断
        // 如果当前行的id和下一行的id相等
        // 就把当前v.rowspan + 1
        // 下一行的v.rowspan - 1
        for (let j = i + 1; j < this.tableData.length; j++) {
          //此处可根据相同字段进行合并，此处是根据的id
          if (this.tableData[i].majorName === this.tableData[j].majorName) {
            this.tableData[i].rowspan++;
            this.tableData[j].rowspan--;
          }
        }
        // 这里跳过已经重复的数据
        i = i + this.tableData[i].rowspan - 1;
      }
    },
    // 渲染表格头，首先是年月，如2018年11月
    getChartTitle(startDate, endDate) {
      var chartTable = this.tableData;
      // 准备日期，为了防止多次赋值属性，导致计算属性重新计算，决定只赋值一次
      let maxDayParams = "",
        minDayParams = "";

      for (var i = 0; i < chartTable.length; i++) {
        var StartDate = chartTable[i].startTime
          ? chartTable[i].startTime
          : "2021.7.15";
        var EndDate = chartTable[i].endTime
          ? chartTable[i].endTime
          : "2021.7.15";
        var mainObj = chartTable[i];

        // 计划日期
        maxDayParams === "" ? (maxDayParams = EndDate) : "";
        minDayParams === "" ? (minDayParams = StartDate) : "";
        maxDayParams = this.compareDate(EndDate, maxDayParams, true);
        minDayParams = this.compareDate(StartDate, minDayParams, false);
        var days = this.GetNumberOfDays(StartDate, EndDate); // 计算工期
        this.tableData[i].days = days + 1; // 加一是因为没算结算当天
        // 记录时间戳
        this.tableData[i].beginTimeStamp = this.getTimeStamp(StartDate);
        this.tableData[i].endTimeStamp = this.getTimeStamp(EndDate);
      }
      this.minDay = minDayParams;
      this.maxDay = maxDayParams;
      console.log("小：" + this.minDay);
      console.log("大：" + this.maxDay);

      this.getYearArr();
      console.log(this.showMonths);
    },

    // 获取需要的格式的年月日信息
    getYearArr() {
      // 如果有一个日期相差超过366天，按照年，不超过则按天
      var days = this.GetNumberOfDays(this.minDay, this.maxDay);
      if (days >= 365) {
        //需要记录月份
        this.IsShowyear = true;
      } else {
        //需要记录天数
        this.IsShowyear = false;
      }
      console.log("609", this.IsShowyear);
      // 获取需要格式的年月信息
      let yearArr = []; // 存年

      let minYear = new Date(this.minDay).getFullYear();
      let maxYear = new Date(this.maxDay).getFullYear();
      // 保存年
      if (minYear === maxYear) {
        yearArr.push({
          year: minYear + "",
          months: [], // 放月的数组
          days: [],
        });
      } else {
        for (let i = minYear; i <= maxYear; i++) {
          yearArr.push({
            year: i + "",
            months: [], // 放月的数组
            days: [],
          });
        }
      }
      // 保存月
      for (let i = 0; i < yearArr.length; i++) {
        let minMonth = 1;
        if (i === 0) {
          minMonth = new Date(this.minDay).getMonth() + 1;
        }
        // 1.eg：2021年9月 至 2019年01月
        // 2.如果只有一个年，那么月份就是最小月到最大月
        if (yearArr.length > 1) {
          // 如果是最后一年，那么就要判断是否到最后一个月
          if (yearArr.length - 1 === i) {
            let maxMonth = new Date(this.maxDay).getMonth() + 1;
            let _maxDay = new Date(this.maxDay).getDate(); // 最大日期 天数
            let j = 1;
            while (j <= maxMonth) {
              let monthsDays = this.getLastDay(yearArr[i].year, j); // 获取月份一共有多少天
              let timestampstr = this.getTimeStamp(
                yearArr[i].year + "-" + (j > 9 ? j : "0" + j) + "-" + monthsDays
              );
              let timestampstr1 = this.getTimeStamp(
                yearArr[i].year + "-" + (j > 9 ? j : "0" + j) + "-01"
              );
              yearArr[i].months.push({
                str: j,
                num: j,
                endTimeStamp: timestampstr,
                beginTimeStamp: timestampstr1,
              }); // 记录最大最小的时间戳
              // 如果显示月|天 才用记录天
              if (!this.IsShowyear) {
                yearArr[i].days[yearArr[i].days.length] = {
                  year: "",
                  month: "",
                  daysArr: {},
                };
                yearArr[i].days[yearArr[i].days.length - 1].year =
                  yearArr[i].year; // 赋值年
                yearArr[i].days[yearArr[i].days.length - 1].month = j; // 赋值月
                yearArr[i].days[yearArr[i].days.length - 1].daysArr = [];
                // 如果结束月，不是到本月最后一天，而是截止到最
                // if (j === maxMonth) {
                //   monthsDays = _maxDay;
                // }
                for (let k = 1; k <= monthsDays; k++) {
                  timestampstr = this.getTimeStamp(
                    yearArr[i].year +
                      "-" +
                      (j > 9 ? j : "0" + j) +
                      "-" +
                      (k > 9 ? k : "0" + k)
                  );
                  // console.log("679", `${yearArr[i].year}-${j}-${k}`);
                  if (new Date(`${yearArr[i].year}-${j}-${k}`).getDay() == 0) {
                    // console.log(new Date(`${yearArr[i].year}-${j}-${k}`).getDay());
                    yearArr[i].days[yearArr[i].days.length - 1].daysArr.push({
                      day: k + "",
                      timestamp: timestampstr,
                    }); // 赋值天
                  }
                }
              }
              j++;
            }
          } else {
            if (i === 0) {
              let j = minMonth;
              let _minDay = new Date(this.minDay).getDate(); // 最小日期 天数

              while (j <= 12) {
                let monthsDays = this.getLastDay(yearArr[i].year, j); // 获取月份一共有多少天
                let timestampstr = this.getTimeStamp(
                  yearArr[i].year +
                    "-" +
                    (j > 9 ? j : "0" + j) +
                    "-" +
                    monthsDays
                );
                let timestampstr1 = this.getTimeStamp(
                  yearArr[i].year + "-" + (j > 9 ? j : "0" + j) + "-01"
                );
                yearArr[i].months.push({
                  str: j,
                  num: j,
                  endTimeStamp: timestampstr,
                  beginTimeStamp: timestampstr1,
                }); // 记录最大最小的时间戳
                // 如果显示月|天 才用记录天
                if (!this.IsShowyear) {
                  yearArr[i].days[yearArr[i].days.length] = {
                    year: "",
                    month: "",
                    daysArr: {},
                  };
                  yearArr[i].days[yearArr[i].days.length - 1].year =
                    yearArr[i].year; // 赋值月
                  yearArr[i].days[yearArr[i].days.length - 1].month = j; // 赋值月
                  yearArr[i].days[yearArr[i].days.length - 1].daysArr = [];
                  for (let k = 1; k <= monthsDays; k++) {
                    // 如果开始月，就不从1日开始，而是从最开始的日期那天开始算起
                    // if (k === 1 && j === minMonth) {
                    //   k = _minDay;
                    // }
                    timestampstr = this.getTimeStamp(
                      yearArr[i].year +
                        "-" +
                        (j > 9 ? j : "0" + j) +
                        "-" +
                        (k > 9 ? k : "0" + k)
                    );
                    // console.log("734", `${yearArr[i].year}-${j}-${k}`);
                    if (
                      new Date(`${yearArr[i].year}-${j}-${k}`).getDay() == 0
                    ) {
                      // console.log(new Date(`${yearArr[i].year}-${j}-${k}`).getDay());
                      yearArr[i].days[yearArr[i].days.length - 1].daysArr.push({
                        day: k + "",
                        timestamp: timestampstr,
                      }); // 赋值天
                    }
                    // yearArr[i].days[yearArr[i].days.length - 1].daysArr.push({
                    //   day: k + "",
                    //   timestamp: timestampstr,
                    // }); // 赋值天
                  }
                }
                j++;
              }
            } else {
              let j = 1;
              while (j <= 12) {
                let monthsDays = this.getLastDay(yearArr[i].year, j); // 获取月份一共有多少天
                let timestampstr = this.getTimeStamp(
                  yearArr[i].year +
                    "-" +
                    (j > 9 ? j : "0" + j) +
                    "-" +
                    monthsDays
                );
                let timestampstr1 = this.getTimeStamp(
                  yearArr[i].year + "-" + (j > 9 ? j : "0" + j) + "-01"
                );
                yearArr[i].months.push({
                  str: j,
                  num: j,
                  endTimeStamp: timestampstr,
                  beginTimeStamp: timestampstr1,
                }); // 记录最大最小的时间戳
                // 如果显示月|天 才用记录天
                if (!this.IsShowyear) {
                  yearArr[i].days[yearArr[i].days.length] = {
                    year: "",
                    month: "",
                    daysArr: {},
                  };
                  yearArr[i].days[yearArr[i].days.length - 1].year =
                    yearArr[i].year; // 赋值年
                  yearArr[i].days[yearArr[i].days.length - 1].month = j; // 赋值月
                  yearArr[i].days[yearArr[i].days.length - 1].daysArr = [];
                  for (let k = 1; k <= monthsDays; k++) {
                    timestampstr = this.getTimeStamp(
                      yearArr[i].year +
                        "-" +
                        (j > 9 ? j : "0" + j) +
                        "-" +
                        (k > 9 ? k : "0" + k)
                    );
                    // console.log("782", `${yearArr[i].year}-${j}-${k}`);
                    if (
                      new Date(`${yearArr[i].year}-${j}-${k}`).getDay() == 0
                    ) {
                      // console.log(new Date(`${yearArr[i].year}-${j}-${k}`).getDay());
                      yearArr[i].days[yearArr[i].days.length - 1].daysArr.push({
                        day: k + "",
                        timestamp: timestampstr,
                      }); // 赋值天
                    }
                    // yearArr[i].days[yearArr[i].days.length - 1].daysArr.push({
                    //   day: k + "",
                    //   timestamp: timestampstr,
                    // }); // 赋值天
                  }
                }
                j++;
              }
            }
          }
        } else {
          // 如果只有一年那么没有必要判断是否记录天
          let maxMonth = new Date(this.maxDay).getMonth() + 1;
          let _minMonth = minMonth;
          let _minDay = new Date(this.minDay).getDate(); // 最小日期 天数
          let _maxDay = new Date(this.maxDay).getDate(); // 最大日期 天数
          while (_minMonth <= maxMonth) {
            let monthsDays = this.getLastDay(yearArr[i].year, _minMonth); // 获取月份一共有多少天
            let timestampstr = this.getTimeStamp(
              yearArr[i].year +
                "-" +
                (_minMonth > 9 ? _minMonth : "0" + _minMonth) +
                "-" +
                monthsDays
            );
            let timestampstr1 = this.getTimeStamp(
              yearArr[i].year +
                "-" +
                (_minMonth > 9 ? _minMonth : "0" + _minMonth) +
                "-01"
            );
            yearArr[i].months.push({
              str: _minMonth,
              num: _minMonth,
              endTimeStamp: timestampstr,
              beginTimeStamp: timestampstr1,
            }); // 记录最大最小的时间戳
            yearArr[i].days[yearArr[i].days.length] = {
              year: "",
              month: "",
              daysArr: {},
            };
            yearArr[i].days[yearArr[i].days.length - 1].year = yearArr[i].year; // 赋值月
            yearArr[i].days[yearArr[i].days.length - 1].month = _minMonth; // 赋值月
            yearArr[i].days[yearArr[i].days.length - 1].daysArr = [];
            // // 如果结束月，不是到本月最后一天，而是截止到最
            // if (_minMonth === maxMonth) {
            //   monthsDays = _maxDay;
            // }
            for (let k = 1; k <= monthsDays; k++) {
              // 如果开始月，就不从1日开始，而是从最开始的日期那天开始算起
              // if (k === 1 && _minMonth === minMonth) {
              //   k = _minDay;
              // }
              timestampstr = this.getTimeStamp(
                yearArr[i].year +
                  "-" +
                  (_minMonth > 9 ? _minMonth : "0" + _minMonth) +
                  "-" +
                  (k > 9 ? k : "0" + k)
              );
              // console.log(`${yearArr[i].year}-${_minMonth}-${k}`);
              if (
                new Date(`${yearArr[i].year}-${_minMonth}-${k}`).getDay() == 0
              ) {
                // console.log(new Date(`${yearArr[i].year}-${_minMonth}-${k}`).getDay());
                yearArr[i].days[yearArr[i].days.length - 1].daysArr.push({
                  day: k + "",
                  timestamp: timestampstr,
                }); // 赋值天
              }
            }
            _minMonth++;
          }
        }
      }
      this.showMonths = yearArr;
    },

    // 获取月的最后一天
    getLastDay(myyear, mymonth) {
      var new_date = new Date(myyear, mymonth, 0);
      return new_date.getDate();
    },

    // 获得天数
    GetNumberOfDays(date1, date2) {
      //date1：开始日期，date2结束日期
      var a1 = Date.parse(new Date(date1));
      var a2 = Date.parse(new Date(date2));
      var day = parseInt((a2 - a1) / 86400000); //核心：时间戳相减，然后除以天数
      return day;
    },
    // 时间比较 true 比大
    compareDate(dateTime1, dateTime2, condition = true) {
      var formatDate1 = new Date(dateTime1);
      var formatDate2 = new Date(dateTime2);
      if (formatDate1 >= formatDate2) {
        return condition ? dateTime1 : dateTime2;
      } else {
        return condition ? dateTime2 : dateTime1;
      }
    },
    // 获取时间戳
    getTimeStamp(val) {
      return new Date(val).getTime();
    },
    // 点击月份
    monthsClick(y, m) {
      console.log(y, m);
    },
    // 点击周
    dayClick(y, m, d) {
      console.log(y, m, d);
    },
    // 列点击
    headerClick(column, event) {
      console.log("941 column", column);
      console.log("942 event", event);
    },
    // 单元格被点击
    cellClick(row, column, cell, event) {
      console.log("941 row", row);
      console.log("942 column", column);
      console.log("941 cell", cell);
      console.log("942 event", event);
    },
  },
};
</script>

<!-- Add "scoped" attribute to limit CSS to this component only -->
<style scoped lang="less">
.scheduleDialog {
  width: 1600px;
  height: 580px;
  overflow: auto;
}
.inputBox {
  width: fit-content;
  height: auto;
  position: absolute;
  top: 20px;
  right: 80px;
}

.el-table,
.el-table__expanded-cell {
  background-color: #0c2451 !important;
}

.el-table--border,
.el-table--group {
  border-color: #495a79 !important;
  // border: none !important;
}

/* 边框粗一点 */
.barchart .el-table--border td,
.barchart .el-table--border th {
  border-width: 2px;
}
/* 单元格padding */
.barchart .el-table--border th:first-child .cell,
.el-table--border td:first-child .cell {
  padding: 0px;
}
.barchart .el-table th > .cell {
  padding: 0px;
}
/* 单元格高度 */
.barchart .el-table--medium th,
.barchart .el-table--medium td {
  padding: 0px 0px !important;
  height: 25px !important;
}
.barchart .progressCon {
  padding: 0;
  margin: 0;
  position: relative;
}
.barchart .progressUpon {
  background: #ff891d;
  height: 1em;
  /* width: calc(100% + 2px); // +2是因为边框线为2px*/
  z-index: 2;
  position: absolute;
  top: 25%;
  left: -2px;
}
.barchart .progressUpon1 {
  background: #ff891d;
  height: 1em;
}
.barchart .progressDownon {
  background: rgb(255, 209, 102);
  height: 1em;
  /* width: calc(100% + 2px); // +2是因为边框线为2px*/
  z-index: 2;
  position: absolute;
  top: 25%;
  left: 0px;
}
</style>

